home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 22 / Cream of the Crop 22.iso / program / recio215.zip / RERR.C < prev    next >
C/C++ Source or Header  |  1996-10-26  |  6KB  |  160 lines
  1. /*****************************************************************************
  2.    MODULE: rerr.c
  3.   PURPOSE: recio error functions
  4. COPYRIGHT: (C) 1994-1996, William Pierpoint
  5.  COMPILER: Borland C Version 3.1
  6.        OS: MSDOS Version 6.2
  7.   VERSION: 2.15
  8.   RELEASE: October 26, 1996
  9. *****************************************************************************/
  10.  
  11. #include <errno.h>
  12. #include <stdio.h>
  13. #include <stdlib.h>
  14. #include <string.h>
  15.  
  16. #include "recio.h"
  17.  
  18. extern void _rsetexitfn(REC *rp);
  19.  
  20. /* private macros */
  21. #define rflags(rp)       ((rp)->r_flags)
  22.  
  23. /* private module variables */
  24. static void (*_r_errfn)(REC *) = NULL; /* ptr to error function */
  25.  
  26. /****************************************************************************/
  27. char *                       /* returns pointer to field string             */
  28.     _rerrs(                  /* get field string if errfn() cleared error   */
  29.         REC *rp,             /* record pointer                              */
  30.         int  errnum)         /* error number                                */
  31. /****************************************************************************/
  32. {
  33.     char *fldp=NULL;         /* pointer to field string */
  34.  
  35.     if (!rseterr(rp, errnum)) fldp = rflds(rp);
  36.     return fldp;
  37. }
  38.  
  39. /****************************************************************************/
  40. void                           /* returns nothing                           */
  41.     rseterrfn(                 /* registers a callback error function       */
  42.         void(*rerrfn)(REC *rp))/* pointer to error function                 */
  43. /****************************************************************************/
  44. {
  45.     _r_errfn = rerrfn;         /* point to callback function */
  46.     _rsetexitfn(recin);        /* register exit function */
  47. }
  48.  
  49. /****************************************************************************/
  50. void                         /* returns nothing                             */
  51.     rclearerr(               /* clears eof and error indicators             */
  52.         REC *rp)             /* record pointer                              */
  53. /****************************************************************************/
  54. {
  55.     if (risvalid(rp)) {
  56.         errno = 0;
  57.         rflags(rp) &= ~_R_EOF;
  58.         rflags(rp) &= ~(_R_ERR * _R_ERRMAX);
  59.     } else {
  60.         rseterr(NULL, EINVAL);
  61.     }
  62. }
  63.  
  64. /****************************************************************************/
  65. int                          /* returns error number (0=no error)           */
  66.     rerror(                  /* gets error number for record stream         */
  67.         REC *rp)             /* record pointer                              */
  68. /****************************************************************************/
  69. {
  70.     int errnum;              /* return error number */
  71.  
  72.     if (risvalid(rp)) {
  73.          errnum = rflags(rp) / _R_ERR;
  74.          errnum &= _R_ERRMAX;
  75.     } else {
  76.         errnum = rseterr(NULL, EINVAL);
  77.     }
  78.     return errnum;
  79. }
  80.  
  81. /****************************************************************************/
  82. int                          /* returns possibly modified error number      */
  83.     rseterr(                 /* sets error number and calls error function  */
  84.         REC *rp,             /* record pointer                              */
  85.         int errnum)          /* error number                                */
  86. /****************************************************************************/
  87. {
  88.     /* if valid record pointer and stream error number clear */
  89.     if (risvalid(rp)) {
  90.         if (errnum > _R_ERRMAX) errnum = R_EINVAL;
  91.         if (!rerror(rp)) {
  92.  
  93.             /* set error number on stream */
  94.             rflags(rp) |= _R_ERR * errnum;
  95.  
  96.             /* invoke callback error function */
  97.             if (_r_errfn) _r_errfn(rp);
  98.  
  99.             /* find out if errfn() cleared error */
  100.             errnum = rerror(rp);
  101.         }
  102.  
  103.     /* else invalid record pointer */
  104.     } else {
  105.  
  106.         /* set global error number */
  107.         errno = errnum;
  108.  
  109.         /* invoke callback error function */
  110.         if (_r_errfn) _r_errfn(rp);
  111.  
  112.         /* find out if errfn() cleared error */
  113.         errnum = errno;
  114.     }
  115.  
  116.     /* if errfn cleared error, 0 returned */
  117.     return errnum;
  118. }
  119.  
  120. /****************************************************************************/
  121. char *                       /* returns error message                       */
  122.     rstrerror(               /* gets error message for rerror number        */
  123.         int errnum)          /* error number                                */
  124. /****************************************************************************/
  125. {
  126.     switch (errnum) {
  127.     case 0:         return ("no error");
  128.     case R_EDOM:    return ("out of domain");
  129.     case R_EINVAL:  return ("invalid argument");
  130.     case R_EINVDAT: return ("invalid data");
  131.     case R_EINVMOD: return ("invalid mode");
  132.     case R_EMISDAT: return ("missing data");
  133.     case R_ENOMEM:  return ("out of memory");
  134.     case R_ENOGET:  return ("record is too long");
  135.     case R_ENOPUT:  return ("unable to put data");
  136.     case R_ERANGE:  return ("out of range");
  137.     }
  138.     return ("unknown error");
  139. }
  140.  
  141. /****************************************************************************/
  142. char *                       /* returns error message                       */
  143.     rerrstr(                 /* gets error message for record stream        */
  144.         REC *rp)             /* record pointer                              */
  145. /****************************************************************************/
  146. {
  147.     return (risvalid(rp) ? rstrerror(rerror(rp)) : rstrerror(R_EINVAL));
  148. }
  149.  
  150. /****************************************************************************/
  151. void                         /* returns nothing                             */
  152.     rinit(                   /* initialize recio library                    */
  153.      void(*rerrfn)(REC *rp), /* pointer to error function                   */
  154.      void(*rwarnfn)(REC *rp))/* pointer to warning function                 */
  155. /****************************************************************************/
  156. {
  157.     rseterrfn(rerrfn);
  158.     rsetwarnfn(rwarnfn);
  159. }
  160.